{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第一题：使用sklearn的多层感知机"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实验内容：  \n",
    "1. 使用sklearn.neural_network.MLPClassifier完成手写数字分类任务\n",
    "2. 绘制学习率为3，1，0.1，0.01训练集损失函数的变化曲线"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 读取数据集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们使用的是sklearn里面自带的手写数字数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_digits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据集有这几个键"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['data', 'target', 'frame', 'feature_names', 'target_names', 'images', 'DESCR'])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_digits().keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "打印数据集的描述"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. _digits_dataset:\n",
      "\n",
      "Optical recognition of handwritten digits dataset\n",
      "--------------------------------------------------\n",
      "\n",
      "**Data Set Characteristics:**\n",
      "\n",
      "    :Number of Instances: 5620\n",
      "    :Number of Attributes: 64\n",
      "    :Attribute Information: 8x8 image of integer pixels in the range 0..16.\n",
      "    :Missing Attribute Values: None\n",
      "    :Creator: E. Alpaydin (alpaydin '@' boun.edu.tr)\n",
      "    :Date: July; 1998\n",
      "\n",
      "This is a copy of the test set of the UCI ML hand-written digits datasets\n",
      "https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits\n",
      "\n",
      "The data set contains images of hand-written digits: 10 classes where\n",
      "each class refers to a digit.\n",
      "\n",
      "Preprocessing programs made available by NIST were used to extract\n",
      "normalized bitmaps of handwritten digits from a preprinted form. From a\n",
      "total of 43 people, 30 contributed to the training set and different 13\n",
      "to the test set. 32x32 bitmaps are divided into nonoverlapping blocks of\n",
      "4x4 and the number of on pixels are counted in each block. This generates\n",
      "an input matrix of 8x8 where each element is an integer in the range\n",
      "0..16. This reduces dimensionality and gives invariance to small\n",
      "distortions.\n",
      "\n",
      "For info on NIST preprocessing routines, see M. D. Garris, J. L. Blue, G.\n",
      "T. Candela, D. L. Dimmick, J. Geist, P. J. Grother, S. A. Janet, and C.\n",
      "L. Wilson, NIST Form-Based Handprint Recognition System, NISTIR 5469,\n",
      "1994.\n",
      "\n",
      ".. topic:: References\n",
      "\n",
      "  - C. Kaynak (1995) Methods of Combining Multiple Classifiers and Their\n",
      "    Applications to Handwritten Digit Recognition, MSc Thesis, Institute of\n",
      "    Graduate Studies in Science and Engineering, Bogazici University.\n",
      "  - E. Alpaydin, C. Kaynak (1998) Cascading Classifiers, Kybernetika.\n",
      "  - Ken Tang and Ponnuthurai N. Suganthan and Xi Yao and A. Kai Qin.\n",
      "    Linear dimensionalityreduction using relevance weighted LDA. School of\n",
      "    Electrical and Electronic Engineering Nanyang Technological University.\n",
      "    2005.\n",
      "  - Claudio Gentile. A New Approximate Maximal Margin Classification\n",
      "    Algorithm. NIPS. 2000.\n"
     ]
    }
   ],
   "source": [
    "print(load_digits()['DESCR'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一共1797个样本，每个样本都是$8 \\times 8$的矩阵，因为是灰度的图像，所以只有一个通道  \n",
    "images对应的是原始的图像，data对应的是 $8 \\times 8$ reshape成 $1 \\times 64$ 的数据，target是标记，表示这张图片里面的数字是几"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "打印第一个样本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  5., 13.,  9.,  1.,  0.,  0.],\n",
       "       [ 0.,  0., 13., 15., 10., 15.,  5.,  0.],\n",
       "       [ 0.,  3., 15.,  2.,  0., 11.,  8.,  0.],\n",
       "       [ 0.,  4., 12.,  0.,  0.,  8.,  8.,  0.],\n",
       "       [ 0.,  5.,  8.,  0.,  0.,  9.,  8.,  0.],\n",
       "       [ 0.,  4., 11.,  0.,  1., 12.,  7.,  0.],\n",
       "       [ 0.,  2., 14.,  5., 10., 12.,  0.,  0.],\n",
       "       [ 0.,  0.,  6., 13., 10.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_digits()['images'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对数据集的前十张图片可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, figs = plt.subplots(1, 10, figsize=(10, 4))\n",
    "for f, img, lbl in zip(figs, load_digits()['images'][:10], load_digits()['target'][:10]):\n",
    "    f.imshow(img, cmap = 'gray')\n",
    "    f.set_title(lbl)\n",
    "    f.axes.get_xaxis().set_visible(False)\n",
    "    f.axes.get_yaxis().set_visible(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 划分数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "取40%为测试集，60%为训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainX, testX, trainY, testY = train_test_split(load_digits()['data'], load_digits()['target'], test_size = 0.4, random_state = 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1078, 64), (1078,), (719, 64), (719,))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainX.shape, trainY.shape, testX.shape, testY.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 数据预处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "神经网络的训练方法一般是基于梯度的优化算法，如梯度下降，为了让这类算法能更好的优化神经网络，我们往往需要对数据集进行归一化，这里我们选择对数据进行标准化\n",
    "\n",
    "$$X' = \\frac{X - \\bar{X}}{\\mathrm{std}(X)}$$\n",
    "\n",
    "其中，$\\bar{X}$是均值，$\\mathrm{std}$是标准差。减去均值可以让数据以0为中心，除以标准差可以让数据缩放到一个较小的范围内。这样可以使得梯度的下降方向更多样，同时缩小梯度的数量级，让学习变得稳定。  \n",
    "首先需要对训练集进行标准化，针对每个特征求出其均值和标准差，然后用训练集的每个样本减去均值除以标准差，就得到了新的训练集。然后用测试集的每个样本，减去训练集的均值，除以训练集的标准差，完成对测试集的标准化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 初始化一个标准化器的实例\n",
    "standard = StandardScaler()\n",
    "\n",
    "# 对训练集进行标准化，它会计算训练集的均值和标准差保存起来\n",
    "trainX = standard.fit_transform(trainX)\n",
    "\n",
    "# 使用标准化器在训练集上的均值和标准差，对测试集进行归一化\n",
    "testX = standard.transform(testX)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以打印看一下数据集归一化后的效果，均值很接近0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.4418480839287748e-18, -0.005673919242693978)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainX.mean(), testX.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 引入模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neural_network import MLPClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们使用sklearn中自带的MLPClassifier，MLP是多层感知机(multi-layer perceptron)的简称。  \n",
    "在训练的时候需要指定参数，这里我们需要设置的几个参数有：\n",
    "1. solver: 'sgd'，这个参数的含义是，使用随机梯度下降作为优化算法\n",
    "2. learning_rate: 'constant'，学习率固定，不衰减\n",
    "3. momentum: 0，动量设置为0，这是随机梯度下降需要的一个参数，我们设置为0即可\n",
    "4. max_iter: 设定最大迭代轮数，如果超过这个轮数还没有收敛，就停止训练，并抛出一个warning\n",
    "5. learning_rate_init，这个参数需要我们进行调整，这是学习率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个模型会判断，如果连续两轮损失值都没有减少了，就停止训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MLPClassifier(solver = 'sgd', learning_rate = 'constant', momentum = 0, learning_rate_init = 0.1, max_iter = 500)\n",
    "model.fit(trainX, trainY)\n",
    "prediction = model.predict(testX)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 预测与评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9833101529902643"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(prediction, testY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "精度达到了98%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 绘制训练集损失函数值的变化曲线"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以通过model.loss_curve_获取模型在训练过程中，损失函数损失值的变化曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'loss')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (10, 6))\n",
    "plt.plot(model.loss_curve_)\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到随着迭代轮数的增加，loss降低地越来越缓慢"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 课后部分：请你在一张图内，绘制出学习率为3，学习率为1，学习率为0.1，学习率为0.01，四个模型的损失函数变化曲线，最大迭代轮数为250轮。并结合参数学习率对图形进行分析\n",
    "\n",
    "提示：分别训练4个模型，然后在一张图中分别绘制4个模型的loss_curve_即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "学习率为3精度： 0.9847009735744089\n",
      "学习率为1精度： 0.9847009735744089\n",
      "学习率为0.1精度： 0.9777468706536857\n",
      "学习率为0.01精度： 0.96105702364395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\anaconda3\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:582: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (250) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x27955355b20>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 19981 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 21516 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 23398 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 20064 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 29575 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 19979 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 30340 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 34920 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:214: RuntimeWarning: Glyph 29616 missing from current font.\n",
      "  font.set_text(s, 0.0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 19981 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 21516 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 23398 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 20064 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 29575 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 19979 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 30340 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 34920 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n",
      "D:\\anaconda3\\lib\\site-packages\\matplotlib\\backends\\backend_agg.py:183: RuntimeWarning: Glyph 29616 missing from current font.\n",
      "  font.set_text(s, 0, flags=flags)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = MLPClassifier(solver = 'sgd', learning_rate = 'constant', momentum = 0, learning_rate_init = 3, max_iter = 250)\n",
    "model.fit(trainX, trainY)\n",
    "prediction = model.predict(testX)\n",
    "print(\"学习率为3精度：\",accuracy_score(prediction, testY))\n",
    "\n",
    "modelx = MLPClassifier(solver = 'sgd', learning_rate = 'constant', momentum = 0, learning_rate_init = 1, max_iter = 250)\n",
    "modelx.fit(trainX, trainY)\n",
    "predictionx = modelx.predict(testX)\n",
    "print(\"学习率为1精度：\",accuracy_score(predictionx, testY))\n",
    "\n",
    "modely = MLPClassifier(solver = 'sgd', learning_rate = 'constant', momentum = 0, learning_rate_init = 0.1, max_iter = 250)\n",
    "modely.fit(trainX, trainY)\n",
    "predictiony = modely.predict(testX)\n",
    "print(\"学习率为0.1精度：\",accuracy_score(predictiony, testY))\n",
    "\n",
    "modelz = MLPClassifier(solver = 'sgd', learning_rate = 'constant', momentum = 0, learning_rate_init = 0.01, max_iter = 250)\n",
    "modelz.fit(trainX, trainY)\n",
    "predictionz = modelz.predict(testX)\n",
    "print(\"学习率为0.01精度：\",accuracy_score(predictionz, testY))\n",
    "\n",
    "\n",
    "plt.figure(figsize = (10, 6))\n",
    "plt.plot(model.loss_curve_,'-',label = 'learning_rate:3')\n",
    "plt.plot(modelx.loss_curve_,'-',label = 'learning_rate:1')\n",
    "plt.plot(modely.loss_curve_,'-',label = 'learning_rate:0.1')\n",
    "plt.plot(modelz.loss_curve_,'-',label = 'learning_rate:0.01')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.title(\"不同学习率下的表现\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由上图可以看出，随着学习率的增大，不同阶段的损失函数不同，学习率为3时，损失函数随阶段的变化，减小最快。\n",
    "在设置最大迭代数为250轮的时候，学习率为0.01的没有收敛"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
